package net.interneteidee.dao;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import net.interneteidee.entity.Categoria;
import net.interneteidee.entity.Cliente;
import net.interneteidee.entity.Cliente_;
import net.interneteidee.entity.Fattura;
import net.interneteidee.entity.Fattura_;
import net.interneteidee.entity.LineaFattura;
import net.interneteidee.entity.LineaFattura_;
import net.interneteidee.entity.Ordine;
import net.interneteidee.entity.Ordine_;
import net.interneteidee.entity.Prodotto;

@Stateless
public class OrdineDao extends GenericDao<Ordine>{
	
	public OrdineDao() {
		// TODO Auto-generated constructor stub
		super(Ordine.class);

	}
	
	/**
	 * Restituisce gli ordini la cui dataAccettazione rientra nel range dataDa dataA
	 * e hanno uno stato corretto 
	 * @param dataDa
	 * @param dataA
	 * @param stato può essere evasi , da evadere e da fatturare
	 * @return
	 */
	public List<Ordine> findOrdiniByStato(Date dataDa,Date dataA,String stato){
		
		criteriaQuery = criteriaBuilder.createQuery(Ordine.class);
		Root<Ordine> rootOrdine = criteriaQuery.from(Ordine.class);
		
		Predicate predicatoDataRange = criteriaBuilder.between(rootOrdine.get(Ordine_.dataAccettazione),dataDa,dataA);
		Predicate predicatoStato =   criteriaBuilder.equal(rootOrdine.get(Ordine_.stato), stato);
		
		//Seleziono tutti gli ordini di un dato cliente senza tener conto dello stato
		if(stato.equals("Tutti")) 
			criteriaQuery.select(rootOrdine).distinct(true).where(criteriaBuilder.and(predicatoDataRange));
				
		//Seleziono tutti gli ordini di un dato cliente tenendo conto di un cliente
		else 
			criteriaQuery.select(rootOrdine).distinct(true).where(criteriaBuilder.and(predicatoDataRange,predicatoStato));
														

		return entityManager.createQuery(criteriaQuery).getResultList();
	
	}
	
	/**
	 * Restituisce gli ordini di un dato Cliente la cui dataAccettazione rientra nel range dataDa dataA
	 * e hanno uno stato corretto 
	 * @param dataDa
	 * @param dataA
	 * @param stato può essere evasi , da evadere e da fatturare
	 * @return
	 */
	public List<Ordine> findOrdiniDiUnDatoClienteByStato(Date dataDa,Date dataA,String stato, String principalCliente  ){
		
		
		criteriaQuery = criteriaBuilder.createQuery(Ordine.class);
		Root<Ordine> rootOrdine = criteriaQuery.from(Ordine.class);

		Join<Ordine,Cliente> joinConCliente = rootOrdine.join(Ordine_.cliente);

		
		Predicate predicatoDataRange = criteriaBuilder.between(rootOrdine.get(Ordine_.dataAccettazione),dataDa,dataA);
		Predicate predicatoPrincipal =   criteriaBuilder.equal(joinConCliente.get(Cliente_.principal), principalCliente);
		Predicate predicatoStato =   criteriaBuilder.equal(rootOrdine.get(Ordine_.stato), stato);


		List<Ordine> ordini = new LinkedList<Ordine>();

	
		//Seleziono tutti gli ordini di un dato cliente senza tener conto dello stato
		if(stato.equals("Tutti")) 
			criteriaQuery.select(rootOrdine).distinct(true).where(criteriaBuilder.and(predicatoDataRange,predicatoPrincipal));
		
		
		//Seleziono tutti gli ordini di un dato cliente tenendo conto di un cliente
		else 
			criteriaQuery.select(rootOrdine).distinct(true).where(criteriaBuilder.and(predicatoDataRange,predicatoStato,predicatoPrincipal));
		
		
		ordini = entityManager.createQuery(criteriaQuery).getResultList();
		return ordini;
		
		
	}
	
	public List<Ordine> findOrdiniNonFatturati () {
		
		criteriaQuery = criteriaBuilder.createQuery(Ordine.class);
		Root<Ordine> rootOrdine = criteriaQuery.from(Ordine.class);
		
		Predicate predicatoNonFatturato = criteriaBuilder.notEqual(rootOrdine.get(Ordine_.stato),"fatturato");
		
		List<Ordine> ordiniNonFatturati = new LinkedList<Ordine>();
		
		criteriaQuery.select(rootOrdine).where(predicatoNonFatturato);
		
		ordiniNonFatturati = entityManager.createQuery(criteriaQuery).getResultList();

		return ordiniNonFatturati;
		
	}

}
